Split <math.h> out of <cmath>. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@249742 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/cmath b/include/cmath index 5f9aaed..ebbde18 100644 --- a/include/cmath +++ b/include/cmath
@@ -299,340 +299,11 @@ #include <__config> #include <math.h> -#include <type_traits> - -#ifdef _LIBCPP_MSVCRT -#include "support/win32/math_win32.h" -#endif #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif -// signbit - -#ifdef signbit - -template <class _A1> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_signbit(_A1 __lcpp_x) _NOEXCEPT -{ - return signbit(__lcpp_x); -} - -#undef signbit - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type -signbit(_A1 __lcpp_x) _NOEXCEPT -{ - return __libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x); -} - -#endif // signbit - -// fpclassify - -#ifdef fpclassify - -template <class _A1> -_LIBCPP_ALWAYS_INLINE -int -__libcpp_fpclassify(_A1 __lcpp_x) _NOEXCEPT -{ - return fpclassify(__lcpp_x); -} - -#undef fpclassify - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if<std::is_arithmetic<_A1>::value, int>::type -fpclassify(_A1 __lcpp_x) _NOEXCEPT -{ - return __libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x); -} - -#endif // fpclassify - -// isfinite - -#ifdef isfinite - -template <class _A1> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT -{ - return isfinite(__lcpp_x); -} - -#undef isfinite - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type -isfinite(_A1 __lcpp_x) _NOEXCEPT -{ - return __libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x); -} - -#endif // isfinite - -// isinf - -#ifdef isinf - -template <class _A1> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT -{ - return isinf(__lcpp_x); -} - -#undef isinf - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type -isinf(_A1 __lcpp_x) _NOEXCEPT -{ - return __libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x); -} - -#endif // isinf - -// isnan - -#ifdef isnan - -template <class _A1> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT -{ - return isnan(__lcpp_x); -} - -#undef isnan - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type -isnan(_A1 __lcpp_x) _NOEXCEPT -{ - return __libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x); -} - -#endif // isnan - -// isnormal - -#ifdef isnormal - -template <class _A1> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_isnormal(_A1 __lcpp_x) _NOEXCEPT -{ - return isnormal(__lcpp_x); -} - -#undef isnormal - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type -isnormal(_A1 __lcpp_x) _NOEXCEPT -{ - return __libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x); -} - -#endif // isnormal - -// isgreater - -#ifdef isgreater - -template <class _A1, class _A2> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - return isgreater(__lcpp_x, __lcpp_y); -} - -#undef isgreater - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if -< - std::is_arithmetic<_A1>::value && - std::is_arithmetic<_A2>::value, - bool ->::type -isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_isgreater((type)__lcpp_x, (type)__lcpp_y); -} - -#endif // isgreater - -// isgreaterequal - -#ifdef isgreaterequal - -template <class _A1, class _A2> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - return isgreaterequal(__lcpp_x, __lcpp_y); -} - -#undef isgreaterequal - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if -< - std::is_arithmetic<_A1>::value && - std::is_arithmetic<_A2>::value, - bool ->::type -isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_isgreaterequal((type)__lcpp_x, (type)__lcpp_y); -} - -#endif // isgreaterequal - -// isless - -#ifdef isless - -template <class _A1, class _A2> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - return isless(__lcpp_x, __lcpp_y); -} - -#undef isless - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if -< - std::is_arithmetic<_A1>::value && - std::is_arithmetic<_A2>::value, - bool ->::type -isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_isless((type)__lcpp_x, (type)__lcpp_y); -} - -#endif // isless - -// islessequal - -#ifdef islessequal - -template <class _A1, class _A2> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - return islessequal(__lcpp_x, __lcpp_y); -} - -#undef islessequal - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if -< - std::is_arithmetic<_A1>::value && - std::is_arithmetic<_A2>::value, - bool ->::type -islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_islessequal((type)__lcpp_x, (type)__lcpp_y); -} - -#endif // islessequal - -// islessgreater - -#ifdef islessgreater - -template <class _A1, class _A2> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - return islessgreater(__lcpp_x, __lcpp_y); -} - -#undef islessgreater - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if -< - std::is_arithmetic<_A1>::value && - std::is_arithmetic<_A2>::value, - bool ->::type -islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_islessgreater((type)__lcpp_x, (type)__lcpp_y); -} - -#endif // islessgreater - -// isunordered - -#ifdef isunordered - -template <class _A1, class _A2> -_LIBCPP_ALWAYS_INLINE -bool -__libcpp_isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - return isunordered(__lcpp_x, __lcpp_y); -} - -#undef isunordered - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename std::enable_if -< - std::is_arithmetic<_A1>::value && - std::is_arithmetic<_A2>::value, - bool ->::type -isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y); -} - -#endif // isunordered - _LIBCPP_BEGIN_NAMESPACE_STD using ::signbit; @@ -652,794 +323,130 @@ using ::float_t; using ::double_t; -// abs - -#if defined(__sun__) +#ifndef _AIX using ::abs; #endif -#if !defined(_AIX) && !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY -float -abs(float __lcpp_x) _NOEXCEPT {return fabsf(__lcpp_x);} - -inline _LIBCPP_INLINE_VISIBILITY -double -abs(double __lcpp_x) _NOEXCEPT {return fabs(__lcpp_x);} - -inline _LIBCPP_INLINE_VISIBILITY -long double -abs(long double __lcpp_x) _NOEXCEPT {return fabsl(__lcpp_x);} -#endif // !defined(_AIX) - #ifndef __sun__ - -// acos - using ::acos; using ::acosf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float acos(float __lcpp_x) _NOEXCEPT {return acosf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return acosl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -acos(_A1 __lcpp_x) _NOEXCEPT {return acos((double)__lcpp_x);} - -// asin - using ::asin; using ::asinf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float asin(float __lcpp_x) _NOEXCEPT {return asinf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return asinl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -asin(_A1 __lcpp_x) _NOEXCEPT {return asin((double)__lcpp_x);} - -// atan - using ::atan; using ::atanf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float atan(float __lcpp_x) _NOEXCEPT {return atanf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return atanl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -atan(_A1 __lcpp_x) _NOEXCEPT {return atan((double)__lcpp_x);} - -// atan2 - using ::atan2; using ::atan2f; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT {return atan2f(__lcpp_y, __lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return atan2l(__lcpp_y, __lcpp_x);} -#endif - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -atan2(_A1 __lcpp_y, _A2 __lcpp_x) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return atan2((__result_type)__lcpp_y, (__result_type)__lcpp_x); -} - -// ceil - using ::ceil; using ::ceilf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float ceil(float __lcpp_x) _NOEXCEPT {return ceilf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ceill(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -ceil(_A1 __lcpp_x) _NOEXCEPT {return ceil((double)__lcpp_x);} - -// cos - using ::cos; using ::cosf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float cos(float __lcpp_x) _NOEXCEPT {return cosf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return cosl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -cos(_A1 __lcpp_x) _NOEXCEPT {return cos((double)__lcpp_x);} - -// cosh - using ::cosh; using ::coshf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float cosh(float __lcpp_x) _NOEXCEPT {return coshf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return coshl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -cosh(_A1 __lcpp_x) _NOEXCEPT {return cosh((double)__lcpp_x);} - #endif // __sun__ -// exp using ::exp; using ::expf; #ifndef __sun__ - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float exp(float __lcpp_x) _NOEXCEPT {return expf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return expl(__lcpp_x);} -#endif - - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -exp(_A1 __lcpp_x) _NOEXCEPT {return exp((double)__lcpp_x);} - -// fabs - using ::fabs; using ::fabsf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float fabs(float __lcpp_x) _NOEXCEPT {return fabsf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return fabsl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -fabs(_A1 __lcpp_x) _NOEXCEPT {return fabs((double)__lcpp_x);} - -// floor - using ::floor; using ::floorf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float floor(float __lcpp_x) _NOEXCEPT {return floorf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return floorl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -floor(_A1 __lcpp_x) _NOEXCEPT {return floor((double)__lcpp_x);} - -// fmod - #endif //__sun__ + using ::fmod; using ::fmodf; + #ifndef __sun__ - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fmodf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fmodl(__lcpp_x, __lcpp_y);} -#endif - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -fmod(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return fmod((__result_type)__lcpp_x, (__result_type)__lcpp_y); -} - - -// frexp - using ::frexp; using ::frexpf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexpf(__lcpp_x, __lcpp_e);} -inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexpl(__lcpp_x, __lcpp_e);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -frexp(_A1 __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexp((double)__lcpp_x, __lcpp_e);} - -// ldexp - using ::ldexp; using ::ldexpf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexpf(__lcpp_x, __lcpp_e);} -inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexpl(__lcpp_x, __lcpp_e);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -ldexp(_A1 __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexp((double)__lcpp_x, __lcpp_e);} - -// log - #endif // __sun__ + using ::log; using ::logf; + #ifndef __sun__ - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float log(float __lcpp_x) _NOEXCEPT {return logf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return logl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -log(_A1 __lcpp_x) _NOEXCEPT {return log((double)__lcpp_x);} - - -// log10 - using ::log10; using ::log10f; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float log10(float __lcpp_x) _NOEXCEPT {return log10f(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return log10l(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -log10(_A1 __lcpp_x) _NOEXCEPT {return log10((double)__lcpp_x);} - -// modf - using ::modf; using ::modff; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT {return modff(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return modfl(__lcpp_x, __lcpp_y);} -#endif - -// pow - #endif // __sun__ + using ::pow; using ::powf; #ifndef __sun__ - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return powf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return powl(__lcpp_x, __lcpp_y);} -#endif - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -pow(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return pow((__result_type)__lcpp_x, (__result_type)__lcpp_y); -} - -// sin - using ::sin; using ::sinf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float sin(float __lcpp_x) _NOEXCEPT {return sinf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return sinl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -sin(_A1 __lcpp_x) _NOEXCEPT {return sin((double)__lcpp_x);} - -// sinh - using ::sinh; using ::sinhf; - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float sinh(float __lcpp_x) _NOEXCEPT {return sinhf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return sinhl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -sinh(_A1 __lcpp_x) _NOEXCEPT {return sinh((double)__lcpp_x);} - -// sqrt - #endif // __sun__ + using ::sqrt; using ::sqrtf; - - -#if !(defined(_LIBCPP_MSVCRT) || defined(__sun__) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __lcpp_x) _NOEXCEPT {return sqrtf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return sqrtl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -sqrt(_A1 __lcpp_x) _NOEXCEPT {return sqrt((double)__lcpp_x);} - -// tan - using ::tan; using ::tanf; + #ifndef __sun__ - -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float tan(float __lcpp_x) _NOEXCEPT {return tanf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return tanl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -tan(_A1 __lcpp_x) _NOEXCEPT {return tan((double)__lcpp_x);} - -// tanh - using ::tanh; using ::tanhf; -#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) -inline _LIBCPP_INLINE_VISIBILITY float tanh(float __lcpp_x) _NOEXCEPT {return tanhf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return tanhl(__lcpp_x);} -#endif - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -tanh(_A1 __lcpp_x) _NOEXCEPT {return tanh((double)__lcpp_x);} - -// acosh - #ifndef _LIBCPP_MSVCRT using ::acosh; using ::acoshf; - -inline _LIBCPP_INLINE_VISIBILITY float acosh(float __lcpp_x) _NOEXCEPT {return acoshf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return acoshl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -acosh(_A1 __lcpp_x) _NOEXCEPT {return acosh((double)__lcpp_x);} -#endif - -// asinh - -#ifndef _LIBCPP_MSVCRT using ::asinh; using ::asinhf; - -inline _LIBCPP_INLINE_VISIBILITY float asinh(float __lcpp_x) _NOEXCEPT {return asinhf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return asinhl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -asinh(_A1 __lcpp_x) _NOEXCEPT {return asinh((double)__lcpp_x);} -#endif - -// atanh - -#ifndef _LIBCPP_MSVCRT using ::atanh; using ::atanhf; - -inline _LIBCPP_INLINE_VISIBILITY float atanh(float __lcpp_x) _NOEXCEPT {return atanhf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return atanhl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -atanh(_A1 __lcpp_x) _NOEXCEPT {return atanh((double)__lcpp_x);} -#endif - -// cbrt - -#ifndef _LIBCPP_MSVCRT using ::cbrt; using ::cbrtf; - -inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __lcpp_x) _NOEXCEPT {return cbrtf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return cbrtl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -cbrt(_A1 __lcpp_x) _NOEXCEPT {return cbrt((double)__lcpp_x);} #endif -// copysign - using ::copysign; using ::copysignf; -#if !defined(_VC_CRT_MAJOR_VERSION) || (_VC_CRT_MAJOR_VERSION < 12) -inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x, - float __lcpp_y) _NOEXCEPT { - return copysignf(__lcpp_x, __lcpp_y); -} -inline _LIBCPP_INLINE_VISIBILITY long double -copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT { - return copysignl(__lcpp_x, __lcpp_y); -} -#endif - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y); -} - #ifndef _LIBCPP_MSVCRT - -// erf - using ::erf; using ::erff; - -inline _LIBCPP_INLINE_VISIBILITY float erf(float __lcpp_x) _NOEXCEPT {return erff(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __lcpp_x) _NOEXCEPT {return erfl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -erf(_A1 __lcpp_x) _NOEXCEPT {return erf((double)__lcpp_x);} - -// erfc - using ::erfc; using ::erfcf; - -inline _LIBCPP_INLINE_VISIBILITY float erfc(float __lcpp_x) _NOEXCEPT {return erfcf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __lcpp_x) _NOEXCEPT {return erfcl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -erfc(_A1 __lcpp_x) _NOEXCEPT {return erfc((double)__lcpp_x);} - -// exp2 - using ::exp2; using ::exp2f; - -inline _LIBCPP_INLINE_VISIBILITY float exp2(float __lcpp_x) _NOEXCEPT {return exp2f(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __lcpp_x) _NOEXCEPT {return exp2l(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -exp2(_A1 __lcpp_x) _NOEXCEPT {return exp2((double)__lcpp_x);} - -// expm1 - using ::expm1; using ::expm1f; - -inline _LIBCPP_INLINE_VISIBILITY float expm1(float __lcpp_x) _NOEXCEPT {return expm1f(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __lcpp_x) _NOEXCEPT {return expm1l(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -expm1(_A1 __lcpp_x) _NOEXCEPT {return expm1((double)__lcpp_x);} - -// fdim - using ::fdim; using ::fdimf; - -inline _LIBCPP_INLINE_VISIBILITY float fdim(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fdimf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fdiml(__lcpp_x, __lcpp_y);} - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -fdim(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return fdim((__result_type)__lcpp_x, (__result_type)__lcpp_y); -} - -// fma - using ::fmaf; using ::fma; - -inline _LIBCPP_INLINE_VISIBILITY float fma(float __lcpp_x, float __lcpp_y, float __lcpp_z) _NOEXCEPT {return fmaf(__lcpp_x, __lcpp_y, __lcpp_z);} -inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __lcpp_x, long double __lcpp_y, long double __lcpp_z) _NOEXCEPT {return fmal(__lcpp_x, __lcpp_y, __lcpp_z);} - -template <class _A1, class _A2, class _A3> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value && - is_arithmetic<_A3>::value, - __promote<_A1, _A2, _A3> ->::type -fma(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2, _A3>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value && - is_same<_A3, __result_type>::value)), ""); - return fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z); -} - -// fmax - using ::fmax; using ::fmaxf; - -inline _LIBCPP_INLINE_VISIBILITY float fmax(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fmaxf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fmaxl(__lcpp_x, __lcpp_y);} - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -fmax(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return fmax((__result_type)__lcpp_x, (__result_type)__lcpp_y); -} - -// fmin - using ::fmin; using ::fminf; - -inline _LIBCPP_INLINE_VISIBILITY float fmin(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fminf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fminl(__lcpp_x, __lcpp_y);} - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -fmin(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return fmin((__result_type)__lcpp_x, (__result_type)__lcpp_y); -} - -// hypot - using ::hypot; using ::hypotf; - -inline _LIBCPP_INLINE_VISIBILITY float hypot(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return hypotf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return hypotl(__lcpp_x, __lcpp_y);} - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -hypot(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y); -} - -// ilogb - using ::ilogb; using ::ilogbf; - -inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __lcpp_x) _NOEXCEPT {return ilogbf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __lcpp_x) _NOEXCEPT {return ilogbl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, int>::type -ilogb(_A1 __lcpp_x) _NOEXCEPT {return ilogb((double)__lcpp_x);} - -// lgamma - using ::lgamma; using ::lgammaf; - -inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __lcpp_x) _NOEXCEPT {return lgammaf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __lcpp_x) _NOEXCEPT {return lgammal(__lcpp_x);} - - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -lgamma(_A1 __lcpp_x) _NOEXCEPT {return lgamma((double)__lcpp_x);} - - -// llrint - using ::llrint; using ::llrintf; - -inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __lcpp_x) _NOEXCEPT {return llrintf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __lcpp_x) _NOEXCEPT {return llrintl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, long long>::type -llrint(_A1 __lcpp_x) _NOEXCEPT {return llrint((double)__lcpp_x);} - -// llround - using ::llround; using ::llroundf; - -inline _LIBCPP_INLINE_VISIBILITY long long llround(float __lcpp_x) _NOEXCEPT {return llroundf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __lcpp_x) _NOEXCEPT {return llroundl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, long long>::type -llround(_A1 __lcpp_x) _NOEXCEPT {return llround((double)__lcpp_x);} - -// log1p - using ::log1p; using ::log1pf; - -inline _LIBCPP_INLINE_VISIBILITY float log1p(float __lcpp_x) _NOEXCEPT {return log1pf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __lcpp_x) _NOEXCEPT {return log1pl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -log1p(_A1 __lcpp_x) _NOEXCEPT {return log1p((double)__lcpp_x);} - -// log2 - using ::log2; using ::log2f; - -inline _LIBCPP_INLINE_VISIBILITY float log2(float __lcpp_x) _NOEXCEPT {return log2f(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __lcpp_x) _NOEXCEPT {return log2l(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -log2(_A1 __lcpp_x) _NOEXCEPT {return log2((double)__lcpp_x);} - -// logb - using ::logb; using ::logbf; - -inline _LIBCPP_INLINE_VISIBILITY float logb(float __lcpp_x) _NOEXCEPT {return logbf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __lcpp_x) _NOEXCEPT {return logbl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -logb(_A1 __lcpp_x) _NOEXCEPT {return logb((double)__lcpp_x);} - -// lrint - using ::lrint; using ::lrintf; - -inline _LIBCPP_INLINE_VISIBILITY long lrint(float __lcpp_x) _NOEXCEPT {return lrintf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __lcpp_x) _NOEXCEPT {return lrintl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, long>::type -lrint(_A1 __lcpp_x) _NOEXCEPT {return lrint((double)__lcpp_x);} - -// lround - using ::lround; using ::lroundf; - -inline _LIBCPP_INLINE_VISIBILITY long lround(float __lcpp_x) _NOEXCEPT {return lroundf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long lround(long double __lcpp_x) _NOEXCEPT {return lroundl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, long>::type -lround(_A1 __lcpp_x) _NOEXCEPT {return lround((double)__lcpp_x);} - #endif // _LIBCPP_MSVCRT #endif // __sun__ -// nan - #ifndef _LIBCPP_MSVCRT using ::nan; using ::nanf; @@ -1447,183 +454,28 @@ #ifndef __sun__ #ifndef _LIBCPP_MSVCRT - -// nearbyint - using ::nearbyint; using ::nearbyintf; - -inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __lcpp_x) _NOEXCEPT {return nearbyintf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __lcpp_x) _NOEXCEPT {return nearbyintl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -nearbyint(_A1 __lcpp_x) _NOEXCEPT {return nearbyint((double)__lcpp_x);} - -// nextafter - using ::nextafter; using ::nextafterf; - -inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return nextafterf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nextafterl(__lcpp_x, __lcpp_y);} - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -nextafter(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return nextafter((__result_type)__lcpp_x, (__result_type)__lcpp_y); -} - -// nexttoward - using ::nexttoward; using ::nexttowardf; - -inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttowardf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttowardl(__lcpp_x, __lcpp_y);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttoward((double)__lcpp_x, __lcpp_y);} - -// remainder - using ::remainder; using ::remainderf; - -inline _LIBCPP_INLINE_VISIBILITY float remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return remainderf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return remainderl(__lcpp_x, __lcpp_y);} - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -remainder(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return remainder((__result_type)__lcpp_x, (__result_type)__lcpp_y); -} - -// remquo - using ::remquo; using ::remquof; - -inline _LIBCPP_INLINE_VISIBILITY float remquo(float __lcpp_x, float __lcpp_y, int* __lcpp_z) _NOEXCEPT {return remquof(__lcpp_x, __lcpp_y, __lcpp_z);} -inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __lcpp_x, long double __lcpp_y, int* __lcpp_z) _NOEXCEPT {return remquol(__lcpp_x, __lcpp_y, __lcpp_z);} - -template <class _A1, class _A2> -inline _LIBCPP_INLINE_VISIBILITY -typename __lazy_enable_if -< - is_arithmetic<_A1>::value && - is_arithmetic<_A2>::value, - __promote<_A1, _A2> ->::type -remquo(_A1 __lcpp_x, _A2 __lcpp_y, int* __lcpp_z) _NOEXCEPT -{ - typedef typename __promote<_A1, _A2>::type __result_type; - static_assert((!(is_same<_A1, __result_type>::value && - is_same<_A2, __result_type>::value)), ""); - return remquo((__result_type)__lcpp_x, (__result_type)__lcpp_y, __lcpp_z); -} - -// rint - using ::rint; using ::rintf; - -inline _LIBCPP_INLINE_VISIBILITY float rint(float __lcpp_x) _NOEXCEPT {return rintf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __lcpp_x) _NOEXCEPT {return rintl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -rint(_A1 __lcpp_x) _NOEXCEPT {return rint((double)__lcpp_x);} - -// round - using ::round; using ::roundf; - -inline _LIBCPP_INLINE_VISIBILITY float round(float __lcpp_x) _NOEXCEPT {return roundf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double round(long double __lcpp_x) _NOEXCEPT {return roundl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -round(_A1 __lcpp_x) _NOEXCEPT {return round((double)__lcpp_x);} - -// scalbln - using ::scalbln; using ::scalblnf; - -inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalblnf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalblnl(__lcpp_x, __lcpp_y);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -scalbln(_A1 __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalbln((double)__lcpp_x, __lcpp_y);} - -// scalbn - using ::scalbn; using ::scalbnf; - -inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbnf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbnl(__lcpp_x, __lcpp_y);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -scalbn(_A1 __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbn((double)__lcpp_x, __lcpp_y);} - -// tgamma - using ::tgamma; using ::tgammaf; - -inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __lcpp_x) _NOEXCEPT {return tgammaf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __lcpp_x) _NOEXCEPT {return tgammal(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -tgamma(_A1 __lcpp_x) _NOEXCEPT {return tgamma((double)__lcpp_x);} - -// trunc - using ::trunc; using ::truncf; - -inline _LIBCPP_INLINE_VISIBILITY float trunc(float __lcpp_x) _NOEXCEPT {return truncf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __lcpp_x) _NOEXCEPT {return truncl(__lcpp_x);} - -template <class _A1> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if<is_integral<_A1>::value, double>::type -trunc(_A1 __lcpp_x) _NOEXCEPT {return trunc((double)__lcpp_x);} - #endif // !_LIBCPP_MSVCRT using ::acosl; @@ -1647,6 +499,7 @@ using ::sinhl; using ::sqrtl; using ::tanl; + #ifndef _LIBCPP_MSVCRT using ::tanhl; using ::acoshl; @@ -1654,7 +507,9 @@ using ::atanhl; using ::cbrtl; #endif // !_LIBCPP_MSVCRT + using ::copysignl; + #ifndef _LIBCPP_MSVCRT using ::erfl; using ::erfcl; @@ -1692,6 +547,7 @@ using ::lgamma; using ::lgammaf; #endif // __sun__ + _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP_CMATH diff --git a/include/math.h b/include/math.h new file mode 100644 index 0000000..dc05622 --- /dev/null +++ b/include/math.h
@@ -0,0 +1,1418 @@ +// -*- C++ -*- +//===---------------------------- math.h ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_MATH_H +#define _LIBCPP_MATH_H + +/* + math.h synopsis + +Macros: + + HUGE_VAL + HUGE_VALF // C99 + HUGE_VALL // C99 + INFINITY // C99 + NAN // C99 + FP_INFINITE // C99 + FP_NAN // C99 + FP_NORMAL // C99 + FP_SUBNORMAL // C99 + FP_ZERO // C99 + FP_FAST_FMA // C99 + FP_FAST_FMAF // C99 + FP_FAST_FMAL // C99 + FP_ILOGB0 // C99 + FP_ILOGBNAN // C99 + MATH_ERRNO // C99 + MATH_ERREXCEPT // C99 + math_errhandling // C99 + +Types: + + float_t // C99 + double_t // C99 + +// C90 + +floating_point abs(floating_point x); + +floating_point acos (arithmetic x); +float acosf(float x); +long double acosl(long double x); + +floating_point asin (arithmetic x); +float asinf(float x); +long double asinl(long double x); + +floating_point atan (arithmetic x); +float atanf(float x); +long double atanl(long double x); + +floating_point atan2 (arithmetic y, arithmetic x); +float atan2f(float y, float x); +long double atan2l(long double y, long double x); + +floating_point ceil (arithmetic x); +float ceilf(float x); +long double ceill(long double x); + +floating_point cos (arithmetic x); +float cosf(float x); +long double cosl(long double x); + +floating_point cosh (arithmetic x); +float coshf(float x); +long double coshl(long double x); + +floating_point exp (arithmetic x); +float expf(float x); +long double expl(long double x); + +floating_point fabs (arithmetic x); +float fabsf(float x); +long double fabsl(long double x); + +floating_point floor (arithmetic x); +float floorf(float x); +long double floorl(long double x); + +floating_point fmod (arithmetic x, arithmetic y); +float fmodf(float x, float y); +long double fmodl(long double x, long double y); + +floating_point frexp (arithmetic value, int* exp); +float frexpf(float value, int* exp); +long double frexpl(long double value, int* exp); + +floating_point ldexp (arithmetic value, int exp); +float ldexpf(float value, int exp); +long double ldexpl(long double value, int exp); + +floating_point log (arithmetic x); +float logf(float x); +long double logl(long double x); + +floating_point log10 (arithmetic x); +float log10f(float x); +long double log10l(long double x); + +floating_point modf (floating_point value, floating_point* iptr); +float modff(float value, float* iptr); +long double modfl(long double value, long double* iptr); + +floating_point pow (arithmetic x, arithmetic y); +float powf(float x, float y); +long double powl(long double x, long double y); + +floating_point sin (arithmetic x); +float sinf(float x); +long double sinl(long double x); + +floating_point sinh (arithmetic x); +float sinhf(float x); +long double sinhl(long double x); + +floating_point sqrt (arithmetic x); +float sqrtf(float x); +long double sqrtl(long double x); + +floating_point tan (arithmetic x); +float tanf(float x); +long double tanl(long double x); + +floating_point tanh (arithmetic x); +float tanhf(float x); +long double tanhl(long double x); + +// C99 + +bool signbit(arithmetic x); + +int fpclassify(arithmetic x); + +bool isfinite(arithmetic x); +bool isinf(arithmetic x); +bool isnan(arithmetic x); +bool isnormal(arithmetic x); + +bool isgreater(arithmetic x, arithmetic y); +bool isgreaterequal(arithmetic x, arithmetic y); +bool isless(arithmetic x, arithmetic y); +bool islessequal(arithmetic x, arithmetic y); +bool islessgreater(arithmetic x, arithmetic y); +bool isunordered(arithmetic x, arithmetic y); + +floating_point acosh (arithmetic x); +float acoshf(float x); +long double acoshl(long double x); + +floating_point asinh (arithmetic x); +float asinhf(float x); +long double asinhl(long double x); + +floating_point atanh (arithmetic x); +float atanhf(float x); +long double atanhl(long double x); + +floating_point cbrt (arithmetic x); +float cbrtf(float x); +long double cbrtl(long double x); + +floating_point copysign (arithmetic x, arithmetic y); +float copysignf(float x, float y); +long double copysignl(long double x, long double y); + +floating_point erf (arithmetic x); +float erff(float x); +long double erfl(long double x); + +floating_point erfc (arithmetic x); +float erfcf(float x); +long double erfcl(long double x); + +floating_point exp2 (arithmetic x); +float exp2f(float x); +long double exp2l(long double x); + +floating_point expm1 (arithmetic x); +float expm1f(float x); +long double expm1l(long double x); + +floating_point fdim (arithmetic x, arithmetic y); +float fdimf(float x, float y); +long double fdiml(long double x, long double y); + +floating_point fma (arithmetic x, arithmetic y, arithmetic z); +float fmaf(float x, float y, float z); +long double fmal(long double x, long double y, long double z); + +floating_point fmax (arithmetic x, arithmetic y); +float fmaxf(float x, float y); +long double fmaxl(long double x, long double y); + +floating_point fmin (arithmetic x, arithmetic y); +float fminf(float x, float y); +long double fminl(long double x, long double y); + +floating_point hypot (arithmetic x, arithmetic y); +float hypotf(float x, float y); +long double hypotl(long double x, long double y); + +int ilogb (arithmetic x); +int ilogbf(float x); +int ilogbl(long double x); + +floating_point lgamma (arithmetic x); +float lgammaf(float x); +long double lgammal(long double x); + +long long llrint (arithmetic x); +long long llrintf(float x); +long long llrintl(long double x); + +long long llround (arithmetic x); +long long llroundf(float x); +long long llroundl(long double x); + +floating_point log1p (arithmetic x); +float log1pf(float x); +long double log1pl(long double x); + +floating_point log2 (arithmetic x); +float log2f(float x); +long double log2l(long double x); + +floating_point logb (arithmetic x); +float logbf(float x); +long double logbl(long double x); + +long lrint (arithmetic x); +long lrintf(float x); +long lrintl(long double x); + +long lround (arithmetic x); +long lroundf(float x); +long lroundl(long double x); + +double nan (const char* str); +float nanf(const char* str); +long double nanl(const char* str); + +floating_point nearbyint (arithmetic x); +float nearbyintf(float x); +long double nearbyintl(long double x); + +floating_point nextafter (arithmetic x, arithmetic y); +float nextafterf(float x, float y); +long double nextafterl(long double x, long double y); + +floating_point nexttoward (arithmetic x, long double y); +float nexttowardf(float x, long double y); +long double nexttowardl(long double x, long double y); + +floating_point remainder (arithmetic x, arithmetic y); +float remainderf(float x, float y); +long double remainderl(long double x, long double y); + +floating_point remquo (arithmetic x, arithmetic y, int* pquo); +float remquof(float x, float y, int* pquo); +long double remquol(long double x, long double y, int* pquo); + +floating_point rint (arithmetic x); +float rintf(float x); +long double rintl(long double x); + +floating_point round (arithmetic x); +float roundf(float x); +long double roundl(long double x); + +floating_point scalbln (arithmetic x, long ex); +float scalblnf(float x, long ex); +long double scalblnl(long double x, long ex); + +floating_point scalbn (arithmetic x, int ex); +float scalbnf(float x, int ex); +long double scalbnl(long double x, int ex); + +floating_point tgamma (arithmetic x); +float tgammaf(float x); +long double tgammal(long double x); + +floating_point trunc (arithmetic x); +float truncf(float x); +long double truncl(long double x); + +*/ + +#include <__config> +#include_next <math.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +#ifdef __cplusplus + +// We support including .h headers inside 'extern "C"' contexts, so switch +// back to C++ linkage before including these C++ headers. +extern "C++" { + +#include <type_traits> + +#ifdef _LIBCPP_MSVCRT +#include "support/win32/math_win32.h" +#endif + +// signbit + +#ifdef signbit + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_signbit(_A1 __lcpp_x) _NOEXCEPT +{ + return signbit(__lcpp_x); +} + +#undef signbit + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type +signbit(_A1 __lcpp_x) _NOEXCEPT +{ + return __libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x); +} + +#endif // signbit + +// fpclassify + +#ifdef fpclassify + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +int +__libcpp_fpclassify(_A1 __lcpp_x) _NOEXCEPT +{ + return fpclassify(__lcpp_x); +} + +#undef fpclassify + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_arithmetic<_A1>::value, int>::type +fpclassify(_A1 __lcpp_x) _NOEXCEPT +{ + return __libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x); +} + +#endif // fpclassify + +// isfinite + +#ifdef isfinite + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT +{ + return isfinite(__lcpp_x); +} + +#undef isfinite + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type +isfinite(_A1 __lcpp_x) _NOEXCEPT +{ + return __libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x); +} + +#endif // isfinite + +// isinf + +#ifdef isinf + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT +{ + return isinf(__lcpp_x); +} + +#undef isinf + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type +isinf(_A1 __lcpp_x) _NOEXCEPT +{ + return __libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x); +} + +#endif // isinf + +// isnan + +#ifdef isnan + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT +{ + return isnan(__lcpp_x); +} + +#undef isnan + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type +isnan(_A1 __lcpp_x) _NOEXCEPT +{ + return __libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x); +} + +#endif // isnan + +// isnormal + +#ifdef isnormal + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isnormal(_A1 __lcpp_x) _NOEXCEPT +{ + return isnormal(__lcpp_x); +} + +#undef isnormal + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type +isnormal(_A1 __lcpp_x) _NOEXCEPT +{ + return __libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x); +} + +#endif // isnormal + +// isgreater + +#ifdef isgreater + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + return isgreater(__lcpp_x, __lcpp_y); +} + +#undef isgreater + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + bool +>::type +isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type type; + return __libcpp_isgreater((type)__lcpp_x, (type)__lcpp_y); +} + +#endif // isgreater + +// isgreaterequal + +#ifdef isgreaterequal + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + return isgreaterequal(__lcpp_x, __lcpp_y); +} + +#undef isgreaterequal + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + bool +>::type +isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type type; + return __libcpp_isgreaterequal((type)__lcpp_x, (type)__lcpp_y); +} + +#endif // isgreaterequal + +// isless + +#ifdef isless + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + return isless(__lcpp_x, __lcpp_y); +} + +#undef isless + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + bool +>::type +isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type type; + return __libcpp_isless((type)__lcpp_x, (type)__lcpp_y); +} + +#endif // isless + +// islessequal + +#ifdef islessequal + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + return islessequal(__lcpp_x, __lcpp_y); +} + +#undef islessequal + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + bool +>::type +islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type type; + return __libcpp_islessequal((type)__lcpp_x, (type)__lcpp_y); +} + +#endif // islessequal + +// islessgreater + +#ifdef islessgreater + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + return islessgreater(__lcpp_x, __lcpp_y); +} + +#undef islessgreater + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + bool +>::type +islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type type; + return __libcpp_islessgreater((type)__lcpp_x, (type)__lcpp_y); +} + +#endif // islessgreater + +// isunordered + +#ifdef isunordered + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + return isunordered(__lcpp_x, __lcpp_y); +} + +#undef isunordered + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + bool +>::type +isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type type; + return __libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y); +} + +#endif // isunordered + +#ifndef __sun__ + +// abs + +#if !defined(_AIX) +inline _LIBCPP_INLINE_VISIBILITY +float +abs(float __lcpp_x) _NOEXCEPT {return fabsf(__lcpp_x);} + +inline _LIBCPP_INLINE_VISIBILITY +double +abs(double __lcpp_x) _NOEXCEPT {return fabs(__lcpp_x);} + +inline _LIBCPP_INLINE_VISIBILITY +long double +abs(long double __lcpp_x) _NOEXCEPT {return fabsl(__lcpp_x);} +#endif // !defined(_AIX) + +// acos + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float acos(float __lcpp_x) _NOEXCEPT {return acosf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return acosl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +acos(_A1 __lcpp_x) _NOEXCEPT {return acos((double)__lcpp_x);} + +// asin + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float asin(float __lcpp_x) _NOEXCEPT {return asinf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return asinl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +asin(_A1 __lcpp_x) _NOEXCEPT {return asin((double)__lcpp_x);} + +// atan + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float atan(float __lcpp_x) _NOEXCEPT {return atanf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return atanl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +atan(_A1 __lcpp_x) _NOEXCEPT {return atan((double)__lcpp_x);} + +// atan2 + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT {return atan2f(__lcpp_y, __lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return atan2l(__lcpp_y, __lcpp_x);} +#endif + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +atan2(_A1 __lcpp_y, _A2 __lcpp_x) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return atan2((__result_type)__lcpp_y, (__result_type)__lcpp_x); +} + +// ceil + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float ceil(float __lcpp_x) _NOEXCEPT {return ceilf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ceill(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +ceil(_A1 __lcpp_x) _NOEXCEPT {return ceil((double)__lcpp_x);} + +// cos + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float cos(float __lcpp_x) _NOEXCEPT {return cosf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return cosl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +cos(_A1 __lcpp_x) _NOEXCEPT {return cos((double)__lcpp_x);} + +// cosh + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float cosh(float __lcpp_x) _NOEXCEPT {return coshf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return coshl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +cosh(_A1 __lcpp_x) _NOEXCEPT {return cosh((double)__lcpp_x);} + +// exp + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float exp(float __lcpp_x) _NOEXCEPT {return expf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return expl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +exp(_A1 __lcpp_x) _NOEXCEPT {return exp((double)__lcpp_x);} + +// fabs + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float fabs(float __lcpp_x) _NOEXCEPT {return fabsf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return fabsl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +fabs(_A1 __lcpp_x) _NOEXCEPT {return fabs((double)__lcpp_x);} + +// floor + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float floor(float __lcpp_x) _NOEXCEPT {return floorf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return floorl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +floor(_A1 __lcpp_x) _NOEXCEPT {return floor((double)__lcpp_x);} + +// fmod + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fmodf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fmodl(__lcpp_x, __lcpp_y);} +#endif + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +fmod(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return fmod((__result_type)__lcpp_x, (__result_type)__lcpp_y); +} + +// frexp + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexpf(__lcpp_x, __lcpp_e);} +inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexpl(__lcpp_x, __lcpp_e);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +frexp(_A1 __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexp((double)__lcpp_x, __lcpp_e);} + +// ldexp + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexpf(__lcpp_x, __lcpp_e);} +inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexpl(__lcpp_x, __lcpp_e);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +ldexp(_A1 __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexp((double)__lcpp_x, __lcpp_e);} + +// log + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float log(float __lcpp_x) _NOEXCEPT {return logf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return logl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +log(_A1 __lcpp_x) _NOEXCEPT {return log((double)__lcpp_x);} + +// log10 + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float log10(float __lcpp_x) _NOEXCEPT {return log10f(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return log10l(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +log10(_A1 __lcpp_x) _NOEXCEPT {return log10((double)__lcpp_x);} + +// modf + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT {return modff(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return modfl(__lcpp_x, __lcpp_y);} +#endif + +// pow + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return powf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return powl(__lcpp_x, __lcpp_y);} +#endif + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +pow(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return pow((__result_type)__lcpp_x, (__result_type)__lcpp_y); +} + +// sin + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float sin(float __lcpp_x) _NOEXCEPT {return sinf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return sinl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +sin(_A1 __lcpp_x) _NOEXCEPT {return sin((double)__lcpp_x);} + +// sinh + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float sinh(float __lcpp_x) _NOEXCEPT {return sinhf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return sinhl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +sinh(_A1 __lcpp_x) _NOEXCEPT {return sinh((double)__lcpp_x);} + +// sqrt + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __lcpp_x) _NOEXCEPT {return sqrtf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return sqrtl(__lcpp_x);} +#endif + +#endif // __sun__ +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +sqrt(_A1 __lcpp_x) _NOEXCEPT {return sqrt((double)__lcpp_x);} +#ifndef __sun__ + +// tan + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float tan(float __lcpp_x) _NOEXCEPT {return tanf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return tanl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +tan(_A1 __lcpp_x) _NOEXCEPT {return tan((double)__lcpp_x);} + +// tanh + +#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX)) +inline _LIBCPP_INLINE_VISIBILITY float tanh(float __lcpp_x) _NOEXCEPT {return tanhf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return tanhl(__lcpp_x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +tanh(_A1 __lcpp_x) _NOEXCEPT {return tanh((double)__lcpp_x);} + +// acosh + +#ifndef _LIBCPP_MSVCRT +inline _LIBCPP_INLINE_VISIBILITY float acosh(float __lcpp_x) _NOEXCEPT {return acoshf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return acoshl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +acosh(_A1 __lcpp_x) _NOEXCEPT {return acosh((double)__lcpp_x);} +#endif + +// asinh + +#ifndef _LIBCPP_MSVCRT +inline _LIBCPP_INLINE_VISIBILITY float asinh(float __lcpp_x) _NOEXCEPT {return asinhf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return asinhl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +asinh(_A1 __lcpp_x) _NOEXCEPT {return asinh((double)__lcpp_x);} +#endif + +// atanh + +#ifndef _LIBCPP_MSVCRT +inline _LIBCPP_INLINE_VISIBILITY float atanh(float __lcpp_x) _NOEXCEPT {return atanhf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return atanhl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +atanh(_A1 __lcpp_x) _NOEXCEPT {return atanh((double)__lcpp_x);} +#endif + +// cbrt + +#ifndef _LIBCPP_MSVCRT +inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __lcpp_x) _NOEXCEPT {return cbrtf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return cbrtl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +cbrt(_A1 __lcpp_x) _NOEXCEPT {return cbrt((double)__lcpp_x);} +#endif + +// copysign + +#if !defined(_VC_CRT_MAJOR_VERSION) || (_VC_CRT_MAJOR_VERSION < 12) +inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x, + float __lcpp_y) _NOEXCEPT { + return copysignf(__lcpp_x, __lcpp_y); +} +inline _LIBCPP_INLINE_VISIBILITY long double +copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT { + return copysignl(__lcpp_x, __lcpp_y); +} +#endif + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y); +} + +#ifndef _LIBCPP_MSVCRT + +// erf + +inline _LIBCPP_INLINE_VISIBILITY float erf(float __lcpp_x) _NOEXCEPT {return erff(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __lcpp_x) _NOEXCEPT {return erfl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +erf(_A1 __lcpp_x) _NOEXCEPT {return erf((double)__lcpp_x);} + +// erfc + +inline _LIBCPP_INLINE_VISIBILITY float erfc(float __lcpp_x) _NOEXCEPT {return erfcf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __lcpp_x) _NOEXCEPT {return erfcl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +erfc(_A1 __lcpp_x) _NOEXCEPT {return erfc((double)__lcpp_x);} + +// exp2 + +inline _LIBCPP_INLINE_VISIBILITY float exp2(float __lcpp_x) _NOEXCEPT {return exp2f(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __lcpp_x) _NOEXCEPT {return exp2l(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +exp2(_A1 __lcpp_x) _NOEXCEPT {return exp2((double)__lcpp_x);} + +// expm1 + +inline _LIBCPP_INLINE_VISIBILITY float expm1(float __lcpp_x) _NOEXCEPT {return expm1f(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __lcpp_x) _NOEXCEPT {return expm1l(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +expm1(_A1 __lcpp_x) _NOEXCEPT {return expm1((double)__lcpp_x);} + +// fdim + +inline _LIBCPP_INLINE_VISIBILITY float fdim(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fdimf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fdiml(__lcpp_x, __lcpp_y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +fdim(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return fdim((__result_type)__lcpp_x, (__result_type)__lcpp_y); +} + +// fma + +inline _LIBCPP_INLINE_VISIBILITY float fma(float __lcpp_x, float __lcpp_y, float __lcpp_z) _NOEXCEPT {return fmaf(__lcpp_x, __lcpp_y, __lcpp_z);} +inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __lcpp_x, long double __lcpp_y, long double __lcpp_z) _NOEXCEPT {return fmal(__lcpp_x, __lcpp_y, __lcpp_z);} + +template <class _A1, class _A2, class _A3> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value && + std::is_arithmetic<_A3>::value, + std::__promote<_A1, _A2, _A3> +>::type +fma(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2, _A3>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value && + std::is_same<_A3, __result_type>::value)), ""); + return fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z); +} + +// fmax + +inline _LIBCPP_INLINE_VISIBILITY float fmax(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fmaxf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fmaxl(__lcpp_x, __lcpp_y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +fmax(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return fmax((__result_type)__lcpp_x, (__result_type)__lcpp_y); +} + +// fmin + +inline _LIBCPP_INLINE_VISIBILITY float fmin(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fminf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fminl(__lcpp_x, __lcpp_y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +fmin(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return fmin((__result_type)__lcpp_x, (__result_type)__lcpp_y); +} + +// hypot + +inline _LIBCPP_INLINE_VISIBILITY float hypot(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return hypotf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return hypotl(__lcpp_x, __lcpp_y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +hypot(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y); +} + +// ilogb + +inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __lcpp_x) _NOEXCEPT {return ilogbf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __lcpp_x) _NOEXCEPT {return ilogbl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, int>::type +ilogb(_A1 __lcpp_x) _NOEXCEPT {return ilogb((double)__lcpp_x);} + +// lgamma + +inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __lcpp_x) _NOEXCEPT {return lgammaf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __lcpp_x) _NOEXCEPT {return lgammal(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +lgamma(_A1 __lcpp_x) _NOEXCEPT {return lgamma((double)__lcpp_x);} + +// llrint + +inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __lcpp_x) _NOEXCEPT {return llrintf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __lcpp_x) _NOEXCEPT {return llrintl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, long long>::type +llrint(_A1 __lcpp_x) _NOEXCEPT {return llrint((double)__lcpp_x);} + +// llround + +inline _LIBCPP_INLINE_VISIBILITY long long llround(float __lcpp_x) _NOEXCEPT {return llroundf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __lcpp_x) _NOEXCEPT {return llroundl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, long long>::type +llround(_A1 __lcpp_x) _NOEXCEPT {return llround((double)__lcpp_x);} + +// log1p + +inline _LIBCPP_INLINE_VISIBILITY float log1p(float __lcpp_x) _NOEXCEPT {return log1pf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __lcpp_x) _NOEXCEPT {return log1pl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +log1p(_A1 __lcpp_x) _NOEXCEPT {return log1p((double)__lcpp_x);} + +// log2 + +inline _LIBCPP_INLINE_VISIBILITY float log2(float __lcpp_x) _NOEXCEPT {return log2f(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __lcpp_x) _NOEXCEPT {return log2l(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +log2(_A1 __lcpp_x) _NOEXCEPT {return log2((double)__lcpp_x);} + +// logb + +inline _LIBCPP_INLINE_VISIBILITY float logb(float __lcpp_x) _NOEXCEPT {return logbf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __lcpp_x) _NOEXCEPT {return logbl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +logb(_A1 __lcpp_x) _NOEXCEPT {return logb((double)__lcpp_x);} + +// lrint + +inline _LIBCPP_INLINE_VISIBILITY long lrint(float __lcpp_x) _NOEXCEPT {return lrintf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __lcpp_x) _NOEXCEPT {return lrintl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, long>::type +lrint(_A1 __lcpp_x) _NOEXCEPT {return lrint((double)__lcpp_x);} + +// lround + +inline _LIBCPP_INLINE_VISIBILITY long lround(float __lcpp_x) _NOEXCEPT {return lroundf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long lround(long double __lcpp_x) _NOEXCEPT {return lroundl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, long>::type +lround(_A1 __lcpp_x) _NOEXCEPT {return lround((double)__lcpp_x);} + +// nan + +// nearbyint + +inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __lcpp_x) _NOEXCEPT {return nearbyintf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __lcpp_x) _NOEXCEPT {return nearbyintl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +nearbyint(_A1 __lcpp_x) _NOEXCEPT {return nearbyint((double)__lcpp_x);} + +// nextafter + +inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return nextafterf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nextafterl(__lcpp_x, __lcpp_y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +nextafter(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return nextafter((__result_type)__lcpp_x, (__result_type)__lcpp_y); +} + +// nexttoward + +inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttowardf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttowardl(__lcpp_x, __lcpp_y);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttoward((double)__lcpp_x, __lcpp_y);} + +// remainder + +inline _LIBCPP_INLINE_VISIBILITY float remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return remainderf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return remainderl(__lcpp_x, __lcpp_y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +remainder(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return remainder((__result_type)__lcpp_x, (__result_type)__lcpp_y); +} + +// remquo + +inline _LIBCPP_INLINE_VISIBILITY float remquo(float __lcpp_x, float __lcpp_y, int* __lcpp_z) _NOEXCEPT {return remquof(__lcpp_x, __lcpp_y, __lcpp_z);} +inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __lcpp_x, long double __lcpp_y, int* __lcpp_z) _NOEXCEPT {return remquol(__lcpp_x, __lcpp_y, __lcpp_z);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::__lazy_enable_if +< + std::is_arithmetic<_A1>::value && + std::is_arithmetic<_A2>::value, + std::__promote<_A1, _A2> +>::type +remquo(_A1 __lcpp_x, _A2 __lcpp_y, int* __lcpp_z) _NOEXCEPT +{ + typedef typename std::__promote<_A1, _A2>::type __result_type; + static_assert((!(std::is_same<_A1, __result_type>::value && + std::is_same<_A2, __result_type>::value)), ""); + return remquo((__result_type)__lcpp_x, (__result_type)__lcpp_y, __lcpp_z); +} + +// rint + +inline _LIBCPP_INLINE_VISIBILITY float rint(float __lcpp_x) _NOEXCEPT {return rintf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __lcpp_x) _NOEXCEPT {return rintl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +rint(_A1 __lcpp_x) _NOEXCEPT {return rint((double)__lcpp_x);} + +// round + +inline _LIBCPP_INLINE_VISIBILITY float round(float __lcpp_x) _NOEXCEPT {return roundf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double round(long double __lcpp_x) _NOEXCEPT {return roundl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +round(_A1 __lcpp_x) _NOEXCEPT {return round((double)__lcpp_x);} + +// scalbln + +inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalblnf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalblnl(__lcpp_x, __lcpp_y);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +scalbln(_A1 __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalbln((double)__lcpp_x, __lcpp_y);} + +// scalbn + +inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbnf(__lcpp_x, __lcpp_y);} +inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbnl(__lcpp_x, __lcpp_y);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +scalbn(_A1 __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbn((double)__lcpp_x, __lcpp_y);} + +// tgamma + +inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __lcpp_x) _NOEXCEPT {return tgammaf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __lcpp_x) _NOEXCEPT {return tgammal(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +tgamma(_A1 __lcpp_x) _NOEXCEPT {return tgamma((double)__lcpp_x);} + +// trunc + +inline _LIBCPP_INLINE_VISIBILITY float trunc(float __lcpp_x) _NOEXCEPT {return truncf(__lcpp_x);} +inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __lcpp_x) _NOEXCEPT {return truncl(__lcpp_x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_integral<_A1>::value, double>::type +trunc(_A1 __lcpp_x) _NOEXCEPT {return trunc((double)__lcpp_x);} + +#endif // !_LIBCPP_MSVCRT +#endif // __sun__ + +} // extern "C++" + +#endif // __cplusplus + +#endif // _LIBCPP_MATH_H diff --git a/test/std/depr/depr.c.headers/math_h.pass.cpp b/test/std/depr/depr.c.headers/math_h.pass.cpp index b03a61b..ed12fcf 100644 --- a/test/std/depr/depr.c.headers/math_h.pass.cpp +++ b/test/std/depr/depr.c.headers/math_h.pass.cpp
@@ -9,7 +9,8 @@ // <math.h> -// XFAIL: linux +// NOTE: isinf and isnan are tested separately because they are expected to fail +// on linux. We don't want their expected failure to hide other failures in this file. #include <math.h> #include <type_traits> @@ -17,498 +18,1168 @@ #include "hexfloat.h" +// convertible to int/float/double/etc +template <class T, int N=0> +struct Value { + operator T () { return T(N); } +}; + +// See PR21083 +// Ambiguous is a user-defined type that defines its own overloads of cmath +// functions. When the std overloads are candidates too (by using or adl), +// they should not interfere. +struct Ambiguous : std::true_type { // ADL + operator float () { return 0.f; } + operator double () { return 0.; } +}; +Ambiguous abs(Ambiguous){ return Ambiguous(); } +Ambiguous acos(Ambiguous){ return Ambiguous(); } +Ambiguous asin(Ambiguous){ return Ambiguous(); } +Ambiguous atan(Ambiguous){ return Ambiguous(); } +Ambiguous atan2(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous ceil(Ambiguous){ return Ambiguous(); } +Ambiguous cos(Ambiguous){ return Ambiguous(); } +Ambiguous cosh(Ambiguous){ return Ambiguous(); } +Ambiguous exp(Ambiguous){ return Ambiguous(); } +Ambiguous fabs(Ambiguous){ return Ambiguous(); } +Ambiguous floor(Ambiguous){ return Ambiguous(); } +Ambiguous fmod(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous frexp(Ambiguous, int*){ return Ambiguous(); } +Ambiguous ldexp(Ambiguous, int){ return Ambiguous(); } +Ambiguous log(Ambiguous){ return Ambiguous(); } +Ambiguous log10(Ambiguous){ return Ambiguous(); } +Ambiguous modf(Ambiguous, Ambiguous*){ return Ambiguous(); } +Ambiguous pow(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous sin(Ambiguous){ return Ambiguous(); } +Ambiguous sinh(Ambiguous){ return Ambiguous(); } +Ambiguous sqrt(Ambiguous){ return Ambiguous(); } +Ambiguous tan(Ambiguous){ return Ambiguous(); } +Ambiguous tanh(Ambiguous){ return Ambiguous(); } +Ambiguous signbit(Ambiguous){ return Ambiguous(); } +Ambiguous fpclassify(Ambiguous){ return Ambiguous(); } +Ambiguous isfinite(Ambiguous){ return Ambiguous(); } +Ambiguous isnormal(Ambiguous){ return Ambiguous(); } +Ambiguous isgreater(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous isgreaterequal(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous isless(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous islessequal(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous islessgreater(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous isunordered(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous acosh(Ambiguous){ return Ambiguous(); } +Ambiguous asinh(Ambiguous){ return Ambiguous(); } +Ambiguous atanh(Ambiguous){ return Ambiguous(); } +Ambiguous cbrt(Ambiguous){ return Ambiguous(); } +Ambiguous copysign(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous erf(Ambiguous){ return Ambiguous(); } +Ambiguous erfc(Ambiguous){ return Ambiguous(); } +Ambiguous exp2(Ambiguous){ return Ambiguous(); } +Ambiguous expm1(Ambiguous){ return Ambiguous(); } +Ambiguous fdim(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous fma(Ambiguous, Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous fmax(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous fmin(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous hypot(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous ilogb(Ambiguous){ return Ambiguous(); } +Ambiguous lgamma(Ambiguous){ return Ambiguous(); } +Ambiguous llrint(Ambiguous){ return Ambiguous(); } +Ambiguous llround(Ambiguous){ return Ambiguous(); } +Ambiguous log1p(Ambiguous){ return Ambiguous(); } +Ambiguous log2(Ambiguous){ return Ambiguous(); } +Ambiguous logb(Ambiguous){ return Ambiguous(); } +Ambiguous lrint(Ambiguous){ return Ambiguous(); } +Ambiguous lround(Ambiguous){ return Ambiguous(); } +Ambiguous nearbyint(Ambiguous){ return Ambiguous(); } +Ambiguous nextafter(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous nexttoward(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous remainder(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous remquo(Ambiguous, Ambiguous, int*){ return Ambiguous(); } +Ambiguous rint(Ambiguous){ return Ambiguous(); } +Ambiguous round(Ambiguous){ return Ambiguous(); } +Ambiguous scalbln(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous scalbn(Ambiguous, Ambiguous){ return Ambiguous(); } +Ambiguous tgamma(Ambiguous){ return Ambiguous(); } +Ambiguous trunc(Ambiguous){ return Ambiguous(); } + +void test_abs() +{ + static_assert((std::is_same<decltype(abs((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(abs((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(abs((long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(abs(Ambiguous())), Ambiguous>::value), ""); + assert(abs(-1.) == 1); +} + void test_acos() { + static_assert((std::is_same<decltype(acos((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(acos((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(acos((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(acos((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(acos((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(acos((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(acos((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(acos((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(acos((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(acos((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(acos((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(acosf(0)), float>::value), ""); static_assert((std::is_same<decltype(acosl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(acos(Ambiguous())), Ambiguous>::value), ""); assert(acos(1) == 0); } void test_asin() { + static_assert((std::is_same<decltype(asin((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(asin((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(asin((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(asin((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(asin((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(asin((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(asin((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(asin((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(asin((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(asin((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(asin((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(asinf(0)), float>::value), ""); static_assert((std::is_same<decltype(asinl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(asin(Ambiguous())), Ambiguous>::value), ""); assert(asin(0) == 0); } void test_atan() { + static_assert((std::is_same<decltype(atan((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(atan((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(atan((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(atanf(0)), float>::value), ""); static_assert((std::is_same<decltype(atanl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(atan(Ambiguous())), Ambiguous>::value), ""); assert(atan(0) == 0); } void test_atan2() { + static_assert((std::is_same<decltype(atan2((float)0, (float)0)), float>::value), ""); + static_assert((std::is_same<decltype(atan2((bool)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan2((unsigned short)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan2((int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(atan2((float)0, (unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan2((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan2((long double)0, (unsigned long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(atan2((int)0, (long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan2((int)0, (unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(atan2((double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan2((long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(atan2((float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan2((float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(atan2((double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(atan2f(0,0)), float>::value), ""); static_assert((std::is_same<decltype(atan2l(0,0)), long double>::value), ""); + static_assert((std::is_same<decltype(atan2((int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(atan2(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(atan2(0,1) == 0); } void test_ceil() { + static_assert((std::is_same<decltype(ceil((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(ceil((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(ceil((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(ceil((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(ceil((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(ceil((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(ceil((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(ceil((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(ceil((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(ceil((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(ceil((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(ceilf(0)), float>::value), ""); static_assert((std::is_same<decltype(ceill(0)), long double>::value), ""); + static_assert((std::is_same<decltype(ceil(Ambiguous())), Ambiguous>::value), ""); assert(ceil(0) == 0); } void test_cos() { + static_assert((std::is_same<decltype(cos((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(cos((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(cos((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(cos((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(cos((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(cos((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(cos((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(cos((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(cos((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(cos((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(cos((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(cosf(0)), float>::value), ""); static_assert((std::is_same<decltype(cosl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(cos(Ambiguous())), Ambiguous>::value), ""); assert(cos(0) == 1); } void test_cosh() { + static_assert((std::is_same<decltype(cosh((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(cosh((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(cosh((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(cosh((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(cosh((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(cosh((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(cosh((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(cosh((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(cosh((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(cosh((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(cosh((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(coshf(0)), float>::value), ""); static_assert((std::is_same<decltype(coshl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(cosh(Ambiguous())), Ambiguous>::value), ""); assert(cosh(0) == 1); } void test_exp() { + static_assert((std::is_same<decltype(exp((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(exp((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(exp((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(expf(0)), float>::value), ""); static_assert((std::is_same<decltype(expl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(exp(Ambiguous())), Ambiguous>::value), ""); assert(exp(0) == 1); } void test_fabs() { + static_assert((std::is_same<decltype(fabs((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(fabs((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(fabs((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(fabs((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(fabs((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(fabs((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fabs((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fabs((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fabs((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(fabs((double)0)), double>::value), ""); - static_assert((std::is_same<decltype(fabsf(0.f)), float>::value), ""); - static_assert((std::is_same<decltype(fabsl(0.L)), long double>::value), ""); - assert(fabs(-1.f) == 1); + static_assert((std::is_same<decltype(fabs((long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fabsf(0.0f)), float>::value), ""); + static_assert((std::is_same<decltype(fabsl(0.0L)), long double>::value), ""); + static_assert((std::is_same<decltype(fabs(Ambiguous())), Ambiguous>::value), ""); + assert(fabs(-1) == 1); } void test_floor() { + static_assert((std::is_same<decltype(floor((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(floor((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(floor((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(floor((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(floor((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(floor((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(floor((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(floor((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(floor((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(floor((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(floor((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(floorf(0)), float>::value), ""); static_assert((std::is_same<decltype(floorl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(floor(Ambiguous())), Ambiguous>::value), ""); assert(floor(1) == 1); } void test_fmod() { + static_assert((std::is_same<decltype(fmod((float)0, (float)0)), float>::value), ""); + static_assert((std::is_same<decltype(fmod((bool)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmod((unsigned short)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmod((int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmod((float)0, (unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmod((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmod((long double)0, (unsigned long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmod((int)0, (long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmod((int)0, (unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(fmod((double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmod((long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmod((float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmod((float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmod((double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(fmodf(0,0)), float>::value), ""); static_assert((std::is_same<decltype(fmodl(0,0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmod((int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmod(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(fmod(1.5,1) == .5); } void test_frexp() { int ip; + static_assert((std::is_same<decltype(frexp((float)0, &ip)), float>::value), ""); + static_assert((std::is_same<decltype(frexp((bool)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(frexp((unsigned short)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(frexp((int)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(frexp((unsigned int)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(frexp((long)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(frexp((unsigned long)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(frexp((long long)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(frexp((unsigned long long)0, &ip)), double>::value), ""); static_assert((std::is_same<decltype(frexp((double)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(frexp((long double)0, &ip)), long double>::value), ""); static_assert((std::is_same<decltype(frexpf(0, &ip)), float>::value), ""); static_assert((std::is_same<decltype(frexpl(0, &ip)), long double>::value), ""); + static_assert((std::is_same<decltype(frexp(Ambiguous(), &ip)), Ambiguous>::value), ""); assert(frexp(0, &ip) == 0); } void test_ldexp() { int ip = 1; + static_assert((std::is_same<decltype(ldexp((float)0, ip)), float>::value), ""); + static_assert((std::is_same<decltype(ldexp((bool)0, ip)), double>::value), ""); + static_assert((std::is_same<decltype(ldexp((unsigned short)0, ip)), double>::value), ""); + static_assert((std::is_same<decltype(ldexp((int)0, ip)), double>::value), ""); + static_assert((std::is_same<decltype(ldexp((unsigned int)0, ip)), double>::value), ""); + static_assert((std::is_same<decltype(ldexp((long)0, ip)), double>::value), ""); + static_assert((std::is_same<decltype(ldexp((unsigned long)0, ip)), double>::value), ""); + static_assert((std::is_same<decltype(ldexp((long long)0, ip)), double>::value), ""); + static_assert((std::is_same<decltype(ldexp((unsigned long long)0, ip)), double>::value), ""); static_assert((std::is_same<decltype(ldexp((double)0, ip)), double>::value), ""); + static_assert((std::is_same<decltype(ldexp((long double)0, ip)), long double>::value), ""); static_assert((std::is_same<decltype(ldexpf(0, ip)), float>::value), ""); static_assert((std::is_same<decltype(ldexpl(0, ip)), long double>::value), ""); + static_assert((std::is_same<decltype(ldexp(Ambiguous(), ip)), Ambiguous>::value), ""); assert(ldexp(1, ip) == 2); } void test_log() { + static_assert((std::is_same<decltype(log((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(log((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(log((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(log((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(log((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(log((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(log((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(log((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(logf(0)), float>::value), ""); static_assert((std::is_same<decltype(logl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(log(Ambiguous())), Ambiguous>::value), ""); assert(log(1) == 0); } void test_log10() { + static_assert((std::is_same<decltype(log10((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(log10((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(log10((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(log10((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(log10((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(log10((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log10((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log10((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log10((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(log10((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(log10((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(log10f(0)), float>::value), ""); static_assert((std::is_same<decltype(log10l(0)), long double>::value), ""); + static_assert((std::is_same<decltype(log10(Ambiguous())), Ambiguous>::value), ""); assert(log10(1) == 0); } void test_modf() { + static_assert((std::is_same<decltype(modf((float)0, (float*)0)), float>::value), ""); static_assert((std::is_same<decltype(modf((double)0, (double*)0)), double>::value), ""); + static_assert((std::is_same<decltype(modf((long double)0, (long double*)0)), long double>::value), ""); static_assert((std::is_same<decltype(modff(0, (float*)0)), float>::value), ""); static_assert((std::is_same<decltype(modfl(0, (long double*)0)), long double>::value), ""); + static_assert((std::is_same<decltype(modf(Ambiguous(), (Ambiguous*)0)), Ambiguous>::value), ""); double i; assert(modf(1., &i) == 0); } void test_pow() { + static_assert((std::is_same<decltype(pow((float)0, (float)0)), float>::value), ""); + static_assert((std::is_same<decltype(pow((bool)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(pow((unsigned short)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(pow((int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(pow((float)0, (unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(pow((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(pow((long double)0, (unsigned long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(pow((int)0, (long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(pow((int)0, (unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(pow((double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(pow((long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(pow((float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(pow((float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(pow((double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(powf(0,0)), float>::value), ""); static_assert((std::is_same<decltype(powl(0,0)), long double>::value), ""); + static_assert((std::is_same<decltype(pow((int)0, (int)0)), double>::value), ""); +// static_assert((std::is_same<decltype(pow(Value<int>(), (int)0)), double>::value), ""); +// static_assert((std::is_same<decltype(pow(Value<long double>(), (float)0)), long double>::value), ""); +// static_assert((std::is_same<decltype(pow((float) 0, Value<float>())), float>::value), ""); + static_assert((std::is_same<decltype(pow(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(pow(1,1) == 1); +// assert(pow(Value<int,1>(), Value<float,1>()) == 1); +// assert(pow(1.0f, Value<double,1>()) == 1); +// assert(pow(1.0, Value<int,1>()) == 1); +// assert(pow(Value<long double,1>(), 1LL) == 1); } void test_sin() { + static_assert((std::is_same<decltype(sin((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(sin((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(sin((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(sin((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(sin((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(sin((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(sin((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(sin((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(sin((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(sin((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(sin((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(sinf(0)), float>::value), ""); static_assert((std::is_same<decltype(sinl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(sin(Ambiguous())), Ambiguous>::value), ""); assert(sin(0) == 0); } void test_sinh() { + static_assert((std::is_same<decltype(sinh((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(sinh((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(sinh((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(sinh((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(sinh((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(sinh((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(sinh((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(sinh((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(sinh((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(sinh((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(sinh((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(sinhf(0)), float>::value), ""); static_assert((std::is_same<decltype(sinhl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(sinh(Ambiguous())), Ambiguous>::value), ""); assert(sinh(0) == 0); } void test_sqrt() { + static_assert((std::is_same<decltype(sqrt((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(sqrt((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(sqrt((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(sqrt((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(sqrt((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(sqrt((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(sqrt((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(sqrt((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(sqrt((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(sqrt((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(sqrt((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(sqrtf(0)), float>::value), ""); static_assert((std::is_same<decltype(sqrtl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(sqrt(Ambiguous())), Ambiguous>::value), ""); assert(sqrt(4) == 2); } void test_tan() { + static_assert((std::is_same<decltype(tan((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(tan((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(tan((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(tan((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(tan((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(tan((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(tan((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(tan((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(tan((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(tan((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(tan((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(tanf(0)), float>::value), ""); static_assert((std::is_same<decltype(tanl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(tan(Ambiguous())), Ambiguous>::value), ""); assert(tan(0) == 0); } void test_tanh() { + static_assert((std::is_same<decltype(tanh((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(tanh((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(tanh((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(tanh((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(tanh((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(tanh((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(tanh((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(tanh((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(tanh((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(tanh((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(tanh((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(tanhf(0)), float>::value), ""); static_assert((std::is_same<decltype(tanhl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(tanh(Ambiguous())), Ambiguous>::value), ""); assert(tanh(0) == 0); } void test_signbit() { +#ifdef signbit +#error signbit defined +#endif static_assert((std::is_same<decltype(signbit((float)0)), bool>::value), ""); static_assert((std::is_same<decltype(signbit((double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(signbit(0)), bool>::value), ""); static_assert((std::is_same<decltype(signbit((long double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(signbit(Ambiguous())), Ambiguous>::value), ""); assert(signbit(-1.0) == true); } void test_fpclassify() { +#ifdef fpclassify +#error fpclassify defined +#endif static_assert((std::is_same<decltype(fpclassify((float)0)), int>::value), ""); static_assert((std::is_same<decltype(fpclassify((double)0)), int>::value), ""); + static_assert((std::is_same<decltype(fpclassify(0)), int>::value), ""); static_assert((std::is_same<decltype(fpclassify((long double)0)), int>::value), ""); + static_assert((std::is_same<decltype(fpclassify(Ambiguous())), Ambiguous>::value), ""); assert(fpclassify(-1.0) == FP_NORMAL); } void test_isfinite() { +#ifdef isfinite +#error isfinite defined +#endif static_assert((std::is_same<decltype(isfinite((float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isfinite((double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isfinite(0)), bool>::value), ""); static_assert((std::is_same<decltype(isfinite((long double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isfinite(Ambiguous())), Ambiguous>::value), ""); assert(isfinite(-1.0) == true); } -void test_isinf() -{ - static_assert((std::is_same<decltype(isinf((float)0)), bool>::value), ""); - static_assert((std::is_same<decltype(isinf((double)0)), bool>::value), ""); - static_assert((std::is_same<decltype(isinf((long double)0)), bool>::value), ""); - assert(isinf(-1.0) == false); -} - -void test_isnan() -{ - static_assert((std::is_same<decltype(isnan((float)0)), bool>::value), ""); - static_assert((std::is_same<decltype(isnan((double)0)), bool>::value), ""); - static_assert((std::is_same<decltype(isnan((long double)0)), bool>::value), ""); - assert(isnan(-1.0) == false); -} - void test_isnormal() { +#ifdef isnormal +#error isnormal defined +#endif static_assert((std::is_same<decltype(isnormal((float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isnormal((double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isnormal(0)), bool>::value), ""); static_assert((std::is_same<decltype(isnormal((long double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isnormal(Ambiguous())), Ambiguous>::value), ""); assert(isnormal(-1.0) == true); } void test_isgreater() { +#ifdef isgreater +#error isgreater defined +#endif static_assert((std::is_same<decltype(isgreater((float)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreater((float)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreater((float)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreater((double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreater((double)0, (double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isgreater(0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreater((double)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreater((long double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreater((long double)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreater((long double)0, (long double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isgreater(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(isgreater(-1.0, 0.F) == false); } void test_isgreaterequal() { +#ifdef isgreaterequal +#error isgreaterequal defined +#endif static_assert((std::is_same<decltype(isgreaterequal((float)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((float)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((float)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((double)0, (double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isgreaterequal(0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((double)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((long double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((long double)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isgreaterequal((long double)0, (long double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isgreaterequal(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(isgreaterequal(-1.0, 0.F) == false); } void test_isless() { +#ifdef isless +#error isless defined +#endif static_assert((std::is_same<decltype(isless((float)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isless((float)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isless((float)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isless((double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isless((double)0, (double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isless(0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isless((double)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isless((long double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isless((long double)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isless((long double)0, (long double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isless(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(isless(-1.0, 0.F) == true); } void test_islessequal() { +#ifdef islessequal +#error islessequal defined +#endif static_assert((std::is_same<decltype(islessequal((float)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessequal((float)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessequal((float)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessequal((double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessequal((double)0, (double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(islessequal(0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessequal((double)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessequal((long double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessequal((long double)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessequal((long double)0, (long double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(islessequal(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(islessequal(-1.0, 0.F) == true); } void test_islessgreater() { +#ifdef islessgreater +#error islessgreater defined +#endif static_assert((std::is_same<decltype(islessgreater((float)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessgreater((float)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessgreater((float)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessgreater((double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessgreater((double)0, (double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(islessgreater(0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessgreater((double)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessgreater((long double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessgreater((long double)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(islessgreater((long double)0, (long double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(islessgreater(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(islessgreater(-1.0, 0.F) == true); } void test_isunordered() { +#ifdef isunordered +#error isunordered defined +#endif static_assert((std::is_same<decltype(isunordered((float)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isunordered((float)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isunordered((float)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isunordered((double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isunordered((double)0, (double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isunordered(0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isunordered((double)0, (long double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isunordered((long double)0, (float)0)), bool>::value), ""); static_assert((std::is_same<decltype(isunordered((long double)0, (double)0)), bool>::value), ""); static_assert((std::is_same<decltype(isunordered((long double)0, (long double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isunordered(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(isunordered(-1.0, 0.F) == false); } void test_acosh() { + static_assert((std::is_same<decltype(acosh((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(acosh((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(acosh((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(acosh((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(acosh((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(acosh((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(acosh((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(acosh((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(acosh((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(acosh((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(acosh((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(acoshf(0)), float>::value), ""); static_assert((std::is_same<decltype(acoshl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(acosh(Ambiguous())), Ambiguous>::value), ""); assert(acosh(1) == 0); } void test_asinh() { + static_assert((std::is_same<decltype(asinh((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(asinh((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(asinh((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(asinh((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(asinh((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(asinh((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(asinh((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(asinh((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(asinh((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(asinh((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(asinh((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(asinhf(0)), float>::value), ""); static_assert((std::is_same<decltype(asinhl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(asinh(Ambiguous())), Ambiguous>::value), ""); assert(asinh(0) == 0); } void test_atanh() { + static_assert((std::is_same<decltype(atanh((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(atanh((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(atanh((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(atanh((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(atanh((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(atanh((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(atanh((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(atanh((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(atanh((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(atanh((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(atanh((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(atanhf(0)), float>::value), ""); static_assert((std::is_same<decltype(atanhl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(atanh(Ambiguous())), Ambiguous>::value), ""); assert(atanh(0) == 0); } void test_cbrt() { + static_assert((std::is_same<decltype(cbrt((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(cbrt((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(cbrt((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(cbrt((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(cbrt((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(cbrt((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(cbrt((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(cbrt((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(cbrt((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(cbrt((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(cbrt((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(cbrtf(0)), float>::value), ""); static_assert((std::is_same<decltype(cbrtl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(cbrt(Ambiguous())), Ambiguous>::value), ""); assert(cbrt(1) == 1); } void test_copysign() { + static_assert((std::is_same<decltype(copysign((float)0, (float)0)), float>::value), ""); + static_assert((std::is_same<decltype(copysign((bool)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(copysign((unsigned short)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(copysign((int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(copysign((float)0, (unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(copysign((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(copysign((long double)0, (unsigned long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(copysign((int)0, (long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(copysign((int)0, (unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(copysign((double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(copysign((long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(copysign((float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(copysign((float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(copysign((double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(copysignf(0,0)), float>::value), ""); static_assert((std::is_same<decltype(copysignl(0,0)), long double>::value), ""); + static_assert((std::is_same<decltype(copysign((int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(copysign(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(copysign(1,1) == 1); } void test_erf() { + static_assert((std::is_same<decltype(erf((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(erf((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(erf((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(erf((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(erf((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(erf((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(erf((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(erf((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(erf((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(erf((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(erf((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(erff(0)), float>::value), ""); static_assert((std::is_same<decltype(erfl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(erf(Ambiguous())), Ambiguous>::value), ""); assert(erf(0) == 0); } void test_erfc() { + static_assert((std::is_same<decltype(erfc((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(erfc((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(erfc((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(erfc((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(erfc((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(erfc((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(erfc((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(erfc((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(erfc((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(erfc((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(erfc((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(erfcf(0)), float>::value), ""); static_assert((std::is_same<decltype(erfcl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(erfc(Ambiguous())), Ambiguous>::value), ""); assert(erfc(0) == 1); } void test_exp2() { + static_assert((std::is_same<decltype(exp2((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(exp2((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp2((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp2((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp2((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp2((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp2((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp2((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp2((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(exp2((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(exp2((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(exp2f(0)), float>::value), ""); static_assert((std::is_same<decltype(exp2l(0)), long double>::value), ""); + static_assert((std::is_same<decltype(exp2(Ambiguous())), Ambiguous>::value), ""); assert(exp2(1) == 2); } void test_expm1() { + static_assert((std::is_same<decltype(expm1((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(expm1((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(expm1((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(expm1((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(expm1((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(expm1((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(expm1((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(expm1((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(expm1((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(expm1((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(expm1((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(expm1f(0)), float>::value), ""); static_assert((std::is_same<decltype(expm1l(0)), long double>::value), ""); + static_assert((std::is_same<decltype(expm1(Ambiguous())), Ambiguous>::value), ""); assert(expm1(0) == 0); } void test_fdim() { + static_assert((std::is_same<decltype(fdim((float)0, (float)0)), float>::value), ""); + static_assert((std::is_same<decltype(fdim((bool)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(fdim((unsigned short)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fdim((int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fdim((float)0, (unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(fdim((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fdim((long double)0, (unsigned long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fdim((int)0, (long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fdim((int)0, (unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(fdim((double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fdim((long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fdim((float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fdim((float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fdim((double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(fdimf(0,0)), float>::value), ""); static_assert((std::is_same<decltype(fdiml(0,0)), long double>::value), ""); + static_assert((std::is_same<decltype(fdim((int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(fdim(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(fdim(1,0) == 1); } void test_fma() { + static_assert((std::is_same<decltype(fma((bool)0, (float)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((char)0, (float)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((unsigned)0, (float)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((float)0, (int)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((float)0, (long)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((float)0, (float)0, (unsigned long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((float)0, (float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((float)0, (float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fma((float)0, (float)0, (float)0)), float>::value), ""); + + static_assert((std::is_same<decltype(fma((bool)0, (double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((char)0, (double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((unsigned)0, (double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((double)0, (int)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((double)0, (long)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((double)0, (double)0, (unsigned long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((double)0, (double)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(fma((double)0, (double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(fma((double)0, (double)0, (double)0)), double>::value), ""); + + static_assert((std::is_same<decltype(fma((bool)0, (long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fma((char)0, (long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fma((unsigned)0, (long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fma((long double)0, (int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fma((long double)0, (long)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fma((long double)0, (long double)0, (unsigned long long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fma((long double)0, (long double)0, (float)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fma((double)0, (long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fma((long double)0, (long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmaf(0,0,0)), float>::value), ""); static_assert((std::is_same<decltype(fmal(0,0,0)), long double>::value), ""); + static_assert((std::is_same<decltype(fma(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(fma(1,1,1) == 2); } void test_fmax() { + static_assert((std::is_same<decltype(fmax((float)0, (float)0)), float>::value), ""); + static_assert((std::is_same<decltype(fmax((bool)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmax((unsigned short)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmax((int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmax((float)0, (unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmax((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmax((long double)0, (unsigned long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmax((int)0, (long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmax((int)0, (unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(fmax((double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmax((long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmax((float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmax((float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmax((double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(fmaxf(0,0)), float>::value), ""); static_assert((std::is_same<decltype(fmaxl(0,0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmax((int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmax(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(fmax(1,0) == 1); } void test_fmin() { + static_assert((std::is_same<decltype(fmin((float)0, (float)0)), float>::value), ""); + static_assert((std::is_same<decltype(fmin((bool)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmin((unsigned short)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmin((int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmin((float)0, (unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmin((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmin((long double)0, (unsigned long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmin((int)0, (long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmin((int)0, (unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(fmin((double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmin((long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmin((float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmin((float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmin((double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(fminf(0,0)), float>::value), ""); static_assert((std::is_same<decltype(fminl(0,0)), long double>::value), ""); + static_assert((std::is_same<decltype(fmin((int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(fmin(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(fmin(1,0) == 0); } void test_hypot() { + static_assert((std::is_same<decltype(hypot((float)0, (float)0)), float>::value), ""); + static_assert((std::is_same<decltype(hypot((bool)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(hypot((unsigned short)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(hypot((int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(hypot((float)0, (unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(hypot((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(hypot((long double)0, (unsigned long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(hypot((int)0, (long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(hypot((int)0, (unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(hypot((double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(hypot((long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(hypot((float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(hypot((float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(hypot((double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(hypotf(0,0)), float>::value), ""); static_assert((std::is_same<decltype(hypotl(0,0)), long double>::value), ""); + static_assert((std::is_same<decltype(hypot((int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(hypot(3,4) == 5); } void test_ilogb() { + static_assert((std::is_same<decltype(ilogb((float)0)), int>::value), ""); + static_assert((std::is_same<decltype(ilogb((bool)0)), int>::value), ""); + static_assert((std::is_same<decltype(ilogb((unsigned short)0)), int>::value), ""); + static_assert((std::is_same<decltype(ilogb((int)0)), int>::value), ""); + static_assert((std::is_same<decltype(ilogb((unsigned int)0)), int>::value), ""); + static_assert((std::is_same<decltype(ilogb((long)0)), int>::value), ""); + static_assert((std::is_same<decltype(ilogb((unsigned long)0)), int>::value), ""); + static_assert((std::is_same<decltype(ilogb((long long)0)), int>::value), ""); + static_assert((std::is_same<decltype(ilogb((unsigned long long)0)), int>::value), ""); static_assert((std::is_same<decltype(ilogb((double)0)), int>::value), ""); + static_assert((std::is_same<decltype(ilogb((long double)0)), int>::value), ""); static_assert((std::is_same<decltype(ilogbf(0)), int>::value), ""); static_assert((std::is_same<decltype(ilogbl(0)), int>::value), ""); + static_assert((std::is_same<decltype(ilogb(Ambiguous())), Ambiguous>::value), ""); assert(ilogb(1) == 0); } void test_lgamma() { + static_assert((std::is_same<decltype(lgamma((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(lgamma((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(lgamma((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(lgamma((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(lgamma((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(lgamma((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(lgamma((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(lgamma((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(lgamma((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(lgamma((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(lgamma((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(lgammaf(0)), float>::value), ""); static_assert((std::is_same<decltype(lgammal(0)), long double>::value), ""); + static_assert((std::is_same<decltype(lgamma(Ambiguous())), Ambiguous>::value), ""); assert(lgamma(1) == 0); } void test_llrint() { + static_assert((std::is_same<decltype(llrint((float)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llrint((bool)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llrint((unsigned short)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llrint((int)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llrint((unsigned int)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llrint((long)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llrint((unsigned long)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llrint((long long)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llrint((unsigned long long)0)), long long>::value), ""); static_assert((std::is_same<decltype(llrint((double)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llrint((long double)0)), long long>::value), ""); static_assert((std::is_same<decltype(llrintf(0)), long long>::value), ""); static_assert((std::is_same<decltype(llrintl(0)), long long>::value), ""); + static_assert((std::is_same<decltype(llrint(Ambiguous())), Ambiguous>::value), ""); assert(llrint(1) == 1LL); } void test_llround() { + static_assert((std::is_same<decltype(llround((float)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llround((bool)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llround((unsigned short)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llround((int)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llround((unsigned int)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llround((long)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llround((unsigned long)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llround((long long)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llround((unsigned long long)0)), long long>::value), ""); static_assert((std::is_same<decltype(llround((double)0)), long long>::value), ""); + static_assert((std::is_same<decltype(llround((long double)0)), long long>::value), ""); static_assert((std::is_same<decltype(llroundf(0)), long long>::value), ""); static_assert((std::is_same<decltype(llroundl(0)), long long>::value), ""); + static_assert((std::is_same<decltype(llround(Ambiguous())), Ambiguous>::value), ""); assert(llround(1) == 1LL); } void test_log1p() { + static_assert((std::is_same<decltype(log1p((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(log1p((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(log1p((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(log1p((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(log1p((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(log1p((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log1p((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log1p((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log1p((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(log1p((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(log1p((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(log1pf(0)), float>::value), ""); static_assert((std::is_same<decltype(log1pl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(log1p(Ambiguous())), Ambiguous>::value), ""); assert(log1p(0) == 0); } void test_log2() { + static_assert((std::is_same<decltype(log2((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(log2((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(log2((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(log2((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(log2((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(log2((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log2((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log2((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(log2((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(log2((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(log2((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(log2f(0)), float>::value), ""); static_assert((std::is_same<decltype(log2l(0)), long double>::value), ""); + static_assert((std::is_same<decltype(log2(Ambiguous())), Ambiguous>::value), ""); assert(log2(1) == 0); } void test_logb() { + static_assert((std::is_same<decltype(logb((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(logb((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(logb((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(logb((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(logb((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(logb((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(logb((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(logb((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(logb((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(logb((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(logb((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(logbf(0)), float>::value), ""); static_assert((std::is_same<decltype(logbl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(logb(Ambiguous())), Ambiguous>::value), ""); assert(logb(1) == 0); } void test_lrint() { + static_assert((std::is_same<decltype(lrint((float)0)), long>::value), ""); + static_assert((std::is_same<decltype(lrint((bool)0)), long>::value), ""); + static_assert((std::is_same<decltype(lrint((unsigned short)0)), long>::value), ""); + static_assert((std::is_same<decltype(lrint((int)0)), long>::value), ""); + static_assert((std::is_same<decltype(lrint((unsigned int)0)), long>::value), ""); + static_assert((std::is_same<decltype(lrint((long)0)), long>::value), ""); + static_assert((std::is_same<decltype(lrint((unsigned long)0)), long>::value), ""); + static_assert((std::is_same<decltype(lrint((long long)0)), long>::value), ""); + static_assert((std::is_same<decltype(lrint((unsigned long long)0)), long>::value), ""); static_assert((std::is_same<decltype(lrint((double)0)), long>::value), ""); + static_assert((std::is_same<decltype(lrint((long double)0)), long>::value), ""); static_assert((std::is_same<decltype(lrintf(0)), long>::value), ""); static_assert((std::is_same<decltype(lrintl(0)), long>::value), ""); + static_assert((std::is_same<decltype(lrint(Ambiguous())), Ambiguous>::value), ""); assert(lrint(1) == 1L); } void test_lround() { + static_assert((std::is_same<decltype(lround((float)0)), long>::value), ""); + static_assert((std::is_same<decltype(lround((bool)0)), long>::value), ""); + static_assert((std::is_same<decltype(lround((unsigned short)0)), long>::value), ""); + static_assert((std::is_same<decltype(lround((int)0)), long>::value), ""); + static_assert((std::is_same<decltype(lround((unsigned int)0)), long>::value), ""); + static_assert((std::is_same<decltype(lround((long)0)), long>::value), ""); + static_assert((std::is_same<decltype(lround((unsigned long)0)), long>::value), ""); + static_assert((std::is_same<decltype(lround((long long)0)), long>::value), ""); + static_assert((std::is_same<decltype(lround((unsigned long long)0)), long>::value), ""); static_assert((std::is_same<decltype(lround((double)0)), long>::value), ""); + static_assert((std::is_same<decltype(lround((long double)0)), long>::value), ""); static_assert((std::is_same<decltype(lroundf(0)), long>::value), ""); static_assert((std::is_same<decltype(lroundl(0)), long>::value), ""); + static_assert((std::is_same<decltype(lround(Ambiguous())), Ambiguous>::value), ""); assert(lround(1) == 1L); } @@ -521,96 +1192,229 @@ void test_nearbyint() { + static_assert((std::is_same<decltype(nearbyint((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(nearbyint((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(nearbyint((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(nearbyint((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(nearbyint((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(nearbyint((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(nearbyint((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(nearbyint((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(nearbyint((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(nearbyint((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nearbyint((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(nearbyintf(0)), float>::value), ""); static_assert((std::is_same<decltype(nearbyintl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(nearbyint(Ambiguous())), Ambiguous>::value), ""); assert(nearbyint(1) == 1); } void test_nextafter() { + static_assert((std::is_same<decltype(nextafter((float)0, (float)0)), float>::value), ""); + static_assert((std::is_same<decltype(nextafter((bool)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(nextafter((unsigned short)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nextafter((int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(nextafter((float)0, (unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(nextafter((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(nextafter((long double)0, (unsigned long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(nextafter((int)0, (long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(nextafter((int)0, (unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(nextafter((double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nextafter((long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(nextafter((float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nextafter((float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(nextafter((double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(nextafterf(0,0)), float>::value), ""); static_assert((std::is_same<decltype(nextafterl(0,0)), long double>::value), ""); + static_assert((std::is_same<decltype(nextafter((int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(nextafter(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(nextafter(0,1) == hexfloat<double>(0x1, 0, -1074)); } void test_nexttoward() { + static_assert((std::is_same<decltype(nexttoward((float)0, (long double)0)), float>::value), ""); + static_assert((std::is_same<decltype(nexttoward((bool)0, (long double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nexttoward((unsigned short)0, (long double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nexttoward((int)0, (long double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nexttoward((unsigned int)0, (long double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nexttoward((long)0, (long double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nexttoward((unsigned long)0, (long double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nexttoward((long long)0, (long double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nexttoward((unsigned long long)0, (long double)0)), double>::value), ""); static_assert((std::is_same<decltype(nexttoward((double)0, (long double)0)), double>::value), ""); + static_assert((std::is_same<decltype(nexttoward((long double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(nexttowardf(0, (long double)0)), float>::value), ""); static_assert((std::is_same<decltype(nexttowardl(0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(nexttoward(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(nexttoward(0, 1) == hexfloat<double>(0x1, 0, -1074)); } void test_remainder() { + static_assert((std::is_same<decltype(remainder((float)0, (float)0)), float>::value), ""); + static_assert((std::is_same<decltype(remainder((bool)0, (float)0)), double>::value), ""); + static_assert((std::is_same<decltype(remainder((unsigned short)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(remainder((int)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(remainder((float)0, (unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(remainder((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(remainder((long double)0, (unsigned long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(remainder((int)0, (long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(remainder((int)0, (unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(remainder((double)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(remainder((long double)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(remainder((float)0, (double)0)), double>::value), ""); + static_assert((std::is_same<decltype(remainder((float)0, (long double)0)), long double>::value), ""); + static_assert((std::is_same<decltype(remainder((double)0, (long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(remainderf(0,0)), float>::value), ""); static_assert((std::is_same<decltype(remainderl(0,0)), long double>::value), ""); static_assert((std::is_same<decltype(remainder((int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(remainder(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(remainder(0.5,1) == 0.5); } void test_remquo() { int ip; + static_assert((std::is_same<decltype(remquo((float)0, (float)0, &ip)), float>::value), ""); + static_assert((std::is_same<decltype(remquo((bool)0, (float)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(remquo((unsigned short)0, (double)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(remquo((int)0, (long double)0, &ip)), long double>::value), ""); + static_assert((std::is_same<decltype(remquo((float)0, (unsigned int)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(remquo((double)0, (long)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(remquo((long double)0, (unsigned long)0, &ip)), long double>::value), ""); + static_assert((std::is_same<decltype(remquo((int)0, (long long)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(remquo((int)0, (unsigned long long)0, &ip)), double>::value), ""); static_assert((std::is_same<decltype(remquo((double)0, (double)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(remquo((long double)0, (long double)0, &ip)), long double>::value), ""); + static_assert((std::is_same<decltype(remquo((float)0, (double)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(remquo((float)0, (long double)0, &ip)), long double>::value), ""); + static_assert((std::is_same<decltype(remquo((double)0, (long double)0, &ip)), long double>::value), ""); static_assert((std::is_same<decltype(remquof(0,0, &ip)), float>::value), ""); static_assert((std::is_same<decltype(remquol(0,0, &ip)), long double>::value), ""); + static_assert((std::is_same<decltype(remquo((int)0, (int)0, &ip)), double>::value), ""); + static_assert((std::is_same<decltype(remquo(Ambiguous(), Ambiguous(), &ip)), Ambiguous>::value), ""); assert(remquo(0.5,1, &ip) == 0.5); } void test_rint() { + static_assert((std::is_same<decltype(rint((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(rint((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(rint((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(rint((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(rint((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(rint((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(rint((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(rint((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(rint((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(rint((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(rint((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(rintf(0)), float>::value), ""); static_assert((std::is_same<decltype(rintl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(rint(Ambiguous())), Ambiguous>::value), ""); assert(rint(1) == 1); } void test_round() { + static_assert((std::is_same<decltype(round((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(round((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(round((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(round((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(round((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(round((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(round((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(round((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(round((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(round((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(round((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(roundf(0)), float>::value), ""); static_assert((std::is_same<decltype(roundl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(round(Ambiguous())), Ambiguous>::value), ""); assert(round(1) == 1); } void test_scalbln() { + static_assert((std::is_same<decltype(scalbln((float)0, (long)0)), float>::value), ""); + static_assert((std::is_same<decltype(scalbln((bool)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbln((unsigned short)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbln((int)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbln((unsigned int)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbln((long)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbln((unsigned long)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbln((long long)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbln((unsigned long long)0, (long)0)), double>::value), ""); static_assert((std::is_same<decltype(scalbln((double)0, (long)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbln((long double)0, (long)0)), long double>::value), ""); static_assert((std::is_same<decltype(scalblnf(0, (long)0)), float>::value), ""); static_assert((std::is_same<decltype(scalblnl(0, (long)0)), long double>::value), ""); + static_assert((std::is_same<decltype(scalbln(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(scalbln(1, 1) == 2); } void test_scalbn() { + static_assert((std::is_same<decltype(scalbn((float)0, (int)0)), float>::value), ""); + static_assert((std::is_same<decltype(scalbn((bool)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbn((unsigned short)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbn((int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbn((unsigned int)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbn((long)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbn((unsigned long)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbn((long long)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbn((unsigned long long)0, (int)0)), double>::value), ""); static_assert((std::is_same<decltype(scalbn((double)0, (int)0)), double>::value), ""); + static_assert((std::is_same<decltype(scalbn((long double)0, (int)0)), long double>::value), ""); static_assert((std::is_same<decltype(scalbnf(0, (int)0)), float>::value), ""); static_assert((std::is_same<decltype(scalbnl(0, (int)0)), long double>::value), ""); + static_assert((std::is_same<decltype(scalbn(Ambiguous(), Ambiguous())), Ambiguous>::value), ""); assert(scalbn(1, 1) == 2); } void test_tgamma() { + static_assert((std::is_same<decltype(tgamma((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(tgamma((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(tgamma((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(tgamma((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(tgamma((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(tgamma((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(tgamma((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(tgamma((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(tgamma((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(tgamma((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(tgamma((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(tgammaf(0)), float>::value), ""); static_assert((std::is_same<decltype(tgammal(0)), long double>::value), ""); + static_assert((std::is_same<decltype(tgamma(Ambiguous())), Ambiguous>::value), ""); assert(tgamma(1) == 1); } void test_trunc() { + static_assert((std::is_same<decltype(trunc((float)0)), float>::value), ""); + static_assert((std::is_same<decltype(trunc((bool)0)), double>::value), ""); + static_assert((std::is_same<decltype(trunc((unsigned short)0)), double>::value), ""); + static_assert((std::is_same<decltype(trunc((int)0)), double>::value), ""); + static_assert((std::is_same<decltype(trunc((unsigned int)0)), double>::value), ""); + static_assert((std::is_same<decltype(trunc((long)0)), double>::value), ""); + static_assert((std::is_same<decltype(trunc((unsigned long)0)), double>::value), ""); + static_assert((std::is_same<decltype(trunc((long long)0)), double>::value), ""); + static_assert((std::is_same<decltype(trunc((unsigned long long)0)), double>::value), ""); static_assert((std::is_same<decltype(trunc((double)0)), double>::value), ""); + static_assert((std::is_same<decltype(trunc((long double)0)), long double>::value), ""); static_assert((std::is_same<decltype(truncf(0)), float>::value), ""); static_assert((std::is_same<decltype(truncl(0)), long double>::value), ""); + static_assert((std::is_same<decltype(trunc(Ambiguous())), Ambiguous>::value), ""); assert(trunc(1) == 1); } int main() { + test_abs(); test_acos(); test_asin(); test_atan(); @@ -636,8 +1440,6 @@ test_signbit(); test_fpclassify(); test_isfinite(); - test_isinf(); - test_isnan(); test_isnormal(); test_isgreater(); test_isgreaterequal(); diff --git a/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp b/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp new file mode 100644 index 0000000..cc7eaac --- /dev/null +++ b/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp
@@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <math.h> + +// isinf + +// XFAIL: linux + +#include <math.h> +#include <type_traits> +#include <cassert> + +int main() +{ +#ifdef isinf +#error isinf defined +#endif + static_assert((std::is_same<decltype(isinf((float)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isinf((double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isinf(0)), bool>::value), ""); + static_assert((std::is_same<decltype(isinf((long double)0)), bool>::value), ""); + assert(isinf(-1.0) == false); +} diff --git a/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp b/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp new file mode 100644 index 0000000..118f96b --- /dev/null +++ b/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp
@@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <math.h> + +// isnan + +// XFAIL: linux + +#include <math.h> +#include <type_traits> +#include <cassert> + +int main() +{ +#ifdef isnan +#error isnan defined +#endif + static_assert((std::is_same<decltype(isnan((float)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isnan((double)0)), bool>::value), ""); + static_assert((std::is_same<decltype(isnan(0)), bool>::value), ""); + static_assert((std::is_same<decltype(isnan((long double)0)), bool>::value), ""); + assert(isnan(-1.0) == false); +} 